home *** CD-ROM | disk | FTP | other *** search
/ Experimental BBS Explossion 3 / Experimental BBS Explossion III.iso / graphics / flick_12.zip / ADAPTIVE.S next >
Text File  |  1994-02-18  |  28KB  |  1,163 lines
  1. ;
  2. ;        Flick FLI-format Animation Viewer v1.2          19 Feb 1994
  3. ;        --------------------------------------
  4. ;
  5. ;
  6. ;This program plays FLI/FLC-format bitmapped animation files on any ECS
  7. ;or AGA Amiga running OS2.04 or higher.  FLI/FLC-format files are
  8. ;produced by Autodesk Animator and Autodesk 3D Studio on a PC, as well
  9. ;as by other programs.
  10. ;
  11. ;The files in this archive may be distributed anywhere provided they are
  12. ;unmodified and are not sold for profit.
  13. ;
  14. ;Ownership and copyright of all files remains with the author:
  15. ;
  16. ;    Peter McGavin, 86 Totara Crescent, Lower Hutt, New Zealand.
  17. ;    e-mail: peterm@maths.grace.cri.nz
  18. ;
  19. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  20. ;        xdef    _chunky2planar
  21.  
  22. ; peterm/adaptive7.s
  23. ; Combines peterm/chunky4.s and jmccoull/blitter4pass.s
  24. ; The blitter works on the top portion of the display at the same time as
  25. ; the CPU converts the bottom portion.
  26. ; The blitter has completely finished before the routine returns.
  27. ; Both parts of every call are timed using the EClock.
  28. ; The partition point is recalculated at the end of the call in an attempt
  29. ; to keep the two routines taking about the same amount of time.
  30. ;
  31. ; The following formula is used:
  32. ;
  33. ;    n_blit = n * t_cpu * n_blit / (t_blit * n_cpu + t_cpu * n_blit)
  34. ;
  35. ; where:
  36. ;    n    is the total number of 32-byte units (i.e, width*height/32)
  37. ;    n_blit    is the number of 32-byte units above the partition
  38. ;    n_cpu    is the number of 32-byte units below the partition (=n-n_blit)
  39. ;    t_blit    is the time taken by the blitter in EClock units
  40. ;    t_cpu    is the time taken by the cpu in EClock units
  41. ;
  42. ; ECS Agnus required (for long blits)
  43. ; KS2.0 required (for utility.library and EClock)
  44.  
  45. ;-----------------------------------------------------------------------------
  46. ; Set Macro68 defaults
  47.  
  48.         default    _branch,_word
  49.         default    _adrbasedisp,_word
  50.         default    _pcbasedisp,_word
  51.         default    _outerdisp,_word
  52.         default    _absolute,_abs
  53.  
  54. bltcpt         equ    $048
  55. bltbpt         equ    $04c
  56. bltapt         equ    $050
  57. bltdpt         equ    $054
  58. bltsizv      equ    $05c
  59. bltsizh      equ    $05e
  60. cleanup        equ    $40
  61. _LVOReadEClock    equ    -60
  62. _LVOCacheClearU    equ    -636
  63. _LVOUMult32    equ    -144
  64. _LVOUDivMod32    equ    -156
  65.  
  66. ;-----------------------------------------------------------------------------
  67. ; chunky2planar:    (new Motorola syntax)
  68. ;  a0 -> chunky pixels (in FAST RAM)
  69. ;  a1 -> plane0 (assume other 7 planes are allocated contiguously)
  70. ;  a3 -> tmp chip buffer0, size=width*height
  71. ;  a4 -> tmp chip buffer1, size=width*height
  72. ;  a5 = TimerBase
  73. ;  a6 = GfxBase
  74. ;  d0 = UtilityBase
  75. ;  d1 = width*height/32 (if generic is defined)
  76.  
  77.     ifnd generic
  78. pixels        equ    width*height
  79. plsiz        equ    width*height/8
  80.     endc
  81.  
  82.  
  83.         section    code,code
  84.  
  85.     ifd generic
  86.     ifeq depth-8
  87. _c2p_8::
  88.     else
  89.     ifeq depth-6
  90. _c2p_6::
  91.     else
  92.     ifeq depth-4
  93. _c2p_4::
  94.     endc
  95.     endc
  96.     endc
  97.     else
  98.     ifeq depth-8
  99.         ifeq    width-320
  100. _c2p320x200x8::
  101.         endc
  102.     else
  103.     ifeq depth-6
  104.         ifeq    width-320
  105. _c2p320x200x6::
  106.         endc
  107.     else
  108.         die    "Unrecognised resolution"
  109.     endc
  110.     endc
  111.     endc
  112.  
  113.         movem.l    d2-d7/a2-a6,-(sp)
  114.  
  115. ; save parameters
  116.  
  117.         movea.l    #mybltnode,a2
  118.         move.l    a0,(chunky-mybltnode,a2)
  119.         move.l    a1,(plane0-mybltnode,a2)
  120.         move.l    a3,(buff0-mybltnode,a2)
  121.         move.l    a4,(buff1-mybltnode,a2)
  122.         move.l    a5,(timerbase-mybltnode,a2)
  123.         move.l    a6,(gfxbase-mybltnode,a2)
  124.         move.l    d0,(utilitybase-mybltnode,a2)
  125.  
  126. ; if different size then initialise v_plsiz, v_plsiz_depth and split location
  127.     ifd generic
  128.         cmp.l    (v_plsiz-mybltnode,a2),d1
  129.         beq.b    skip_relocate
  130.         move.l    d1,(v_plsiz-mybltnode,a2)
  131.  
  132.         move.l    d1,d0
  133.         lsr.l    #3,d0
  134.         move.l    d0,(n_blit-mybltnode,a2)
  135.         lsl.l    #2,d0
  136.         move.l    d0,(plsiz_blit-mybltnode,a2)
  137.         lsl.l    #3,d0
  138.         move.l    d0,(pixels_blit-mybltnode,a2)
  139.  
  140.         moveq    #depth-1,d0
  141.         movea.l    (utilitybase-mybltnode,a2),a6
  142.         jsr    (_LVOUMult32,a6)
  143.         move.l    d0,(v_plsiz_depth-mybltnode,a2)
  144.  
  145.         bclr    #0,(firsttimeflag-mybltnode,a2)
  146.         bne.b    skip_relocate
  147.  
  148. ; see if this is the first time thru
  149.     else
  150.         tst.b    (firsttimeflag-mybltnode,a2)
  151.         bne.b    skip_relocate    ; branch if not being called 1st time
  152.     endc
  153.  
  154. ; relocate the mainloop to a quad-longword boundary (for 030/040 cache line)
  155.  
  156.         lea    (begincode,pc),a4
  157.         adda.w    #15,a4
  158.         move.l    a4,d0
  159.         and.w    #~15,d0
  160.         movea.l    d0,a4
  161.         lea    (mainloop,pc),a3
  162.         move.w    #(endcode-mainloop)/2-1,d0
  163. 1$:        move.w    (a3)+,(a4)+
  164.         dbra    d0,1$
  165.  
  166. ; flush the caches
  167.  
  168.         movea.l    (4).w,a6
  169.         jsr    (_LVOCacheClearU,a6)
  170.  
  171. skip_relocate:
  172.  
  173. ; see if chunky data are in CHIP ram
  174.  
  175.         movea.l    (chunky-mybltnode,a2),a1
  176.         move.l    a1,(source-mybltnode,a2)
  177.         movea.l    (4).w,a6
  178.         jsr    (_LVOTypeOfMem,a6)
  179.         and.w    #MEMF_CHIP,d0
  180.         bne.b    readstart    ; branch if already in CHIP
  181.  
  182. ; copy pixels_blit from chunky to buff0 (from FAST to CHIP) for the blitter
  183.  
  184.         movea.l    (chunky-mybltnode,a2),a0
  185.         movea.l    (buff0-mybltnode,a2),a1
  186.         move.l    a1,(source-mybltnode,a2)
  187.         move.l    (pixels_blit-mybltnode,a2),d0
  188.         jsr    (_LVOCopyMemQuick,a6)
  189.  
  190. ; read the start time
  191.  
  192. readstart:    lea    (starttime-mybltnode,a2),a0
  193.         movea.l    (timerbase-mybltnode,a2),a6
  194.         jsr    (_LVOReadEClock,a6)
  195.  
  196. ; start the blitter in the background
  197.  
  198.         st    (waitflag-mybltnode,a2)
  199.         movea.l    a2,a1
  200.         movea.l    (gfxbase-mybltnode,a2),a6
  201.         jsr    (_LVOQBlit,a6)
  202.  
  203. ; compute starting parameters for the CPU routine
  204.  
  205.     ifd generic
  206.         move.l    (v_plsiz-mybltnode,a2),d0
  207.         move.l    d0,-(sp)
  208.         move.l    (v_plsiz_depth-mybltnode,a2),-(sp)
  209.     else
  210.         move.l    #plsiz,d0
  211.     endc
  212.         sub.l    (plsiz_blit-mybltnode,a2),d0
  213.         lsr.l    #2,d0
  214.         move.w    d0,-(sp)    ; outer loop counter on stack
  215.  
  216.         move.l    (chunky-mybltnode,a2),a0
  217.         adda.l    (pixels_blit-mybltnode,a2),a0    ; offset into chunky
  218.  
  219.         move.l    (plane0-mybltnode,a2),a1
  220.         adda.l    (plsiz_blit-mybltnode,a2),a1    ; offset into plane
  221.  
  222.         lea    (buffers-mybltnode,a2),a3    ; a3 -> buffers
  223.  
  224.     ifnd generic
  225.     iflt 4*plsiz-4-32768
  226.         adda.w    #3*plsiz,a1    ; a1 -> plane 3
  227.     else
  228.     iflt 2*plsiz-4-32768
  229.         adda.w    #1*plsiz,a1    ; a1 -> plane 1
  230.     endc
  231.     endc
  232.     endc
  233.  
  234. ; set up register constants
  235.  
  236.         move.l    #$0f0f0f0f,d5    ; d5 = constant $0f0f0f0f
  237.         move.l    #$55555555,d6    ; d6 = constant $55555555
  238.         move.l    #$3333cccc,d7    ; d7 = constant $3333cccc
  239.         lea    (4,a3),a2    ; used for inner loop end test
  240.  
  241. ; load up address registers with buffer ptrs
  242.  
  243.         lea    (2*4,a3),a4    ; a4 -> plane2buf
  244.         lea    (2*4,a4),a5    ; a5 -> plane4buf
  245.         lea    (2*4,a5),a6    ; a6 -> plane6buf
  246.  
  247. begincode:    rept    8        ; space for mainloop code relocation
  248.         nop
  249.         endr
  250.  
  251. ; main loop (starts here) processes 8 chunky pixels at a time
  252.  
  253. mainloop:    move.l    (a0)+,d2    ; 12 get next 4 chunky pixels in d2
  254.         move.l    (a0)+,d3    ; 12 get next 4 chunky pixels in d3
  255.     ifgt depth-4
  256.         move.l    d2,d0        ;  4
  257.         and.l    d5,d2        ;  8 d5=$0f0f0f0f
  258.         move.l    d3,d1        ;  4
  259.         and.l    d5,d3        ;  8 d5=$0f0f0f0f
  260.         eor.l    d2,d0        ;  8
  261.         eor.l    d3,d1        ;  8
  262.         lsr.l    #4,d1        ; 16
  263.         or.l    d1,d0        ;  8
  264.     endc
  265.         lsl.l    #4,d2        ; 16
  266.         or.l    d3,d2        ;  8
  267.         move.l    d2,d3        ;  4
  268.         and.l    d7,d3        ;  8 d7=$3333cccc
  269.         eor.l    d3,d2        ;  8
  270.         lsr.w    #2,d3        ; 10
  271.         swap    d3        ;  4
  272.         lsl.w    #2,d3        ; 10
  273.         or.l    d2,d3        ;  8
  274.     ifgt depth-4
  275.         move.l    d0,d1        ;  4
  276.         and.l    d7,d1        ;  8 d7=$3333cccc
  277.         eor.l    d1,d0        ;  8
  278.         lsr.w    #2,d1        ; 10
  279.         swap    d1        ;  4
  280.         lsl.w    #2,d1        ; 10
  281.         or.l    d0,d1        ;  8
  282.         move.l    d1,d2        ;  4
  283.         lsr.l    #7,d2        ; 22
  284.         move.l    d1,d0        ;  4
  285.         and.l    d6,d0        ;  8 d6=$55555555
  286.     endc
  287.     ifgt depth-4
  288.         eor.l    d0,d1        ;  8
  289.         move.l    d2,d4        ;  4
  290.         and.l    d6,d4        ;  8 d6=$55555555
  291.         eor.l    d4,d2        ;  8
  292. restart:    or.l    d4,d1        ;  8
  293.         lsr.l    #1,d1        ; 10
  294.         move.b    d1,(4,a5)    ; 12 plane 5
  295.     ifgt depth-6
  296.         swap    d1        ;  4
  297.         move.b    d1,(4,a6)    ; 12 plane 7
  298.     endc
  299.         or.l    d0,d2        ;  8
  300.         move.b    d2,(a5)+    ;  8 plane 4
  301.     ifgt depth-6
  302.         swap    d2        ;  4
  303.         move.b    d2,(a6)+    ;  8 plane 6
  304.     endc
  305.     endc
  306.         move.l    d3,d2        ;  4
  307.         lsr.l    #7,d2        ; 22
  308.         move.l    d3,d0        ;  4
  309.         and.l    d6,d0        ;  8 d6=$55555555
  310.         eor.l    d0,d3        ;  8
  311.         move.l    d2,d4        ;  4
  312.         and.l    d6,d4        ;  8 d6=$55555555
  313.         eor.l    d4,d2        ;  8
  314.         or.l    d4,d3        ;  8
  315.         lsr.l    #1,d3        ; 10
  316. restart2:    move.b    d3,(4,a3)    ; 12 plane 1
  317.         swap    d3        ;  4
  318.         move.b    d3,(4,a4)    ; 12 plane 3
  319.         or.l    d0,d2        ;  8
  320.         move.b    d2,(a3)+    ;  8 plane 0
  321.         swap    d2        ;  4
  322.         move.b    d2,(a4)+    ;  8 plane 2
  323.  
  324.         cmpa.l    a3,a2        ;128  6
  325.         bne.w    mainloop    ;130 10    total=512 (64.0 cycles/pixel)
  326.  
  327. ; move stack buffers to bitplanes (longword writes) and restore ptrs
  328. ; Intersperse some instructions for the next loop between writes to do something
  329. ; useful while waiting for the Chip bus.
  330. ; Do this by defining macros b0..b8 which are then interleaved with some
  331. ; instructions for next loop.
  332. ; Check if finished, go back for more.
  333.  
  334.     ifd generic
  335. b0        macro
  336.         move.l    (6,sp),d4        ; (v_plsiz) a1 points at plane 0
  337.         adda.l    (2,sp),a1        ; (v_plsiz_depth)
  338.         endm
  339. b1        macro
  340.         move.l    (a6),(a1)        ; plane 7
  341.         suba.l    d4,a1            ;
  342.         endm
  343. b2        macro
  344.         move.l    -(a6),(a1)        ; plane 6
  345.         suba.l    d4,a1            ;
  346.         endm
  347. b3        macro
  348.         move.l    (a5),(a1)        ; plane 5
  349.         suba.l    d4,a1            ;
  350.         endm
  351. b4        macro
  352.         move.l    -(a5),(a1)        ; plane 4
  353.         suba.l    d4,a1            ;
  354.         endm
  355. b5        macro
  356.         move.l    (a4),(a1)        ; plane 3
  357.         suba.l    d4,a1            ;
  358.         endm
  359. b6        macro
  360.         move.l    -(a4),(a1)        ; plane 2
  361.         suba.l    d4,a1            ;
  362.         endm
  363. b7        macro
  364.         move.l    (a3),(a1)        ; plane 1
  365.         suba.l    d4,a1            ;
  366.         endm
  367. b8        macro
  368.         move.l    -(a3),(a1)+        ; plane 0
  369.         endm
  370.     endc
  371.  
  372.     ifnd generic
  373.     iflt 4*plsiz-4-32768        ;    a1 points into plane 3
  374. b0        macro
  375.         move.l    (a4),(a1)+        ; plane 3
  376.         endm
  377. b1        macro
  378.         endm
  379. b2        macro
  380.         move.l    (a6),(4*plsiz-4,a1)    ; plane 7
  381.         endm
  382. b3        macro
  383.         move.l    -(a6),(3*plsiz-4,a1)    ; plane 6
  384.         endm
  385. b4        macro
  386.         move.l    (a5),(2*plsiz-4,a1)    ; plane 5
  387.         endm
  388. b5        macro
  389.         move.l    -(a5),(1*plsiz-4,a1)    ; plane 4
  390.         endm
  391. b6        macro
  392.         move.l    -(a4),(-1*plsiz-4,a1)    ; plane 2
  393.         endm
  394. b7        macro
  395.         move.l    (a3),(-2*plsiz-4,a1)    ; plane 1
  396.         endm
  397. b8        macro
  398.         move.l    -(a3),(-3*plsiz-4,a1)    ; plane 0
  399.         endm
  400.     endc
  401.     endc
  402.  
  403.     ifnd generic
  404.     ifge 4*plsiz-4-32768
  405.     iflt 2*plsiz-32768            ; a1 points into plane 1
  406. b0        macro
  407.     ifgt depth-4
  408.         adda.l    #4*plsiz,a1
  409.     endc
  410.         endm
  411. b1        macro
  412.         move.l    (a6),(2*plsiz,a1)    ; plane 7
  413.         endm
  414. b2        macro
  415.         move.l    -(a6),(1*plsiz,a1)    ; plane 6
  416.         endm
  417. b3        macro
  418.         move.l    (a5),(0*plsiz,a1)    ; plane 5
  419.         endm
  420. b4        macro
  421.         move.l    -(a5),(-1*plsiz,a1)    ; plane 4
  422.         suba.l    #4*plsiz,a1
  423.         endm
  424. b5        macro
  425.         move.l    (a4),(2*plsiz,a1)    ; plane 3
  426.         endm
  427. b6        macro
  428.         move.l    -(a4),(1*plsiz,a1)    ; plane 2
  429.         endm
  430. b7        macro
  431.         move.l    (a3),(a1)+        ; plane 1
  432.         endm
  433. b8        macro
  434.         move.l    -(a3),(-1*plsiz-4,a1)    ; plane 0
  435.         endm
  436.     endc
  437.     endc
  438.     endc
  439.  
  440.     ifnd generic
  441.     ifge 2*plsiz-32768            ; a1 points into plane 1
  442.     iflt plsiz-32768            ; a1 points into plane 0
  443. b0        macro
  444.     ifgt plsiz-5
  445.         adda.l    #6*plsiz,a1
  446.     else
  447.         adda.l    #3*plsiz,a1
  448.     endc
  449.         endm
  450. b1        macro
  451.         move.l    (a6),(plsiz,a1)        ; plane 7
  452.         endm
  453. b2        macro
  454.         move.l    -(a6),(a1)        ; plane 6
  455.         endm
  456. b3        macro
  457.         move.l    (a5),(-plsiz,a1)    ; plane 5
  458.         suba.l    #3*plsiz,a1
  459.         endm
  460. b4        macro
  461.         move.l    -(a5),(plsiz,a1)    ; plane 4
  462.         endm
  463. b5        macro
  464.         move.l    (a4),(a1)        ; plane 3
  465.         endm
  466. b6        macro
  467.         move.l    -(a4),(-plsiz,a1)    ; plane 2
  468.         suba.l    #3*plsiz,a1
  469.         endm
  470. b7        macro
  471.         move.l    (a3),(plsiz,a1)        ; plane 1
  472.         endm
  473. b8        macro
  474.         move.l    -(a3),(a1)+        ; plane 0
  475.         endm
  476.     endc
  477.     endc
  478.     endc
  479.  
  480.     ifnd generic
  481.     ifge plsiz-32768            ; a1 points into plane 0
  482. b0        macro
  483.         move.l    #plsiz,d4
  484.         adda.l    #(depth-1)*plsiz,a1
  485.         endm
  486. b1        macro
  487.         move.l    (a6),(a1)        ; plane 7
  488.         suba.l    d4,a1
  489.         endm
  490. b2        macro
  491.         move.l    -(a6),(a1)        ; plane 6
  492.         suba.l    d4,a1
  493.         endm
  494. b3        macro
  495.         move.l    (a5),(a1)        ; plane 5
  496.         suba.l    d4,a1
  497.         endm
  498. b4        macro
  499.         move.l    -(a5),(a1)        ; plane 4
  500.         suba.l    d4,a1
  501.         endm
  502. b5        macro
  503.         move.l    (a4),(a1)        ; plane 3
  504.         suba.l    d4,a1
  505.         endm
  506. b6        macro
  507.         move.l    -(a4),(a1)        ; plane 2
  508.         suba.l    d4,a1
  509.         endm
  510. b7        macro
  511.         move.l    (a3),(a1)        ; plane 1
  512.         suba.l    d4,a1
  513.         endm
  514. b8        macro
  515.         move.l    -(a3),(a1)+        ; plane 0
  516.         endm
  517.     endc
  518.     endc
  519.  
  520. ; Now use the macros b0..b8 interleaved in instructions for next loop
  521.  
  522. ; 8 planes
  523.     ifeq depth-8
  524.         b0
  525.         b1                ; plane 7
  526.         move.l    (a0)+,d2    ; 12 get next 4 chunky pixels in d2
  527.         move.l    (a0)+,d3    ; 12 get next 4 chunky pixels in d3
  528.         move.l    d2,d0        ;  4
  529.         and.l    d5,d2        ;  8 d5=$0f0f0f0f
  530.         b2                ; plane 6
  531.         move.l    d3,d1        ;  4
  532.         and.l    d5,d3        ;  8 d5=$0f0f0f0f
  533.         eor.l    d2,d0        ;  8
  534.         eor.l    d3,d1        ;  8
  535.         lsr.l    #4,d1        ; 16
  536.         b3                ; plane 5
  537.         or.l    d1,d0        ;  8
  538.         lsl.l    #4,d2        ; 16
  539.         or.l    d3,d2        ;  8
  540.         move.l    d2,d3        ;  4
  541.         and.l    d7,d3        ;  8 d7=$3333cccc
  542.         b4                ; plane 4
  543.         eor.l    d3,d2        ;  8
  544.         lsr.w    #2,d3        ; 10
  545.         swap    d3        ;  4
  546.         lsl.w    #2,d3        ; 10
  547.         or.l    d2,d3        ;  8
  548.         b5                ; plane 3
  549.         move.l    d0,d1        ;  4
  550.         and.l    d7,d1        ;  8 d7=$3333cccc
  551.         eor.l    d1,d0        ;  8
  552.         lsr.w    #2,d1        ; 10
  553.         swap    d1        ;  4
  554.         b6                ; plane 2
  555.         lsl.w    #2,d1        ; 10
  556.         or.l    d0,d1        ;  8
  557.         move.l    d1,d2        ;  4
  558.         lsr.l    #7,d2        ; 22
  559.         move.l    d1,d0        ;  4
  560.         b7                ; plane 1
  561.         and.l    d6,d0        ;  8 d6=$55555555
  562.         eor.l    d0,d1        ;  8
  563.         move.l    d2,d4        ;  4
  564.         and.l    d6,d4        ;  8 d6=$55555555
  565.         eor.l    d4,d2        ;  8
  566.         b8                ; plane 0
  567.         sub.w    #1,(sp)
  568.         bne.w    restart
  569.     else
  570.     ifeq depth-6
  571.         b0
  572.         b3                ; plane 5
  573.         move.l    (a0)+,d2    ; 12 get next 4 chunky pixels in d2
  574.         move.l    (a0)+,d3    ; 12 get next 4 chunky pixels in d3
  575.         move.l    d2,d0        ;  4
  576.         and.l    d5,d2        ;  8 d5=$0f0f0f0f
  577.         move.l    d3,d1        ;  4
  578.         and.l    d5,d3        ;  8 d5=$0f0f0f0f
  579.         b4                ; plane 4
  580.         eor.l    d2,d0        ;  8
  581.         eor.l    d3,d1        ;  8
  582.         lsr.l    #4,d1        ; 16
  583.         or.l    d1,d0        ;  8
  584.         lsl.l    #4,d2        ; 16
  585.         or.l    d3,d2        ;  8
  586.         b5                ; plane 3
  587.         move.l    d2,d3        ;  4
  588.         and.l    d7,d3        ;  8 d7=$3333cccc
  589.         eor.l    d3,d2        ;  8
  590.         lsr.w    #2,d3        ; 10
  591.         swap    d3        ;  4
  592.         lsl.w    #2,d3        ; 10
  593.         b6                ; plane 2
  594.         or.l    d2,d3        ;  8
  595.         move.l    d0,d1        ;  4
  596.         and.l    d7,d1        ;  8 d7=$3333cccc
  597.         eor.l    d1,d0        ;  8
  598.         lsr.w    #2,d1        ; 10
  599.         swap    d1        ;  4
  600.         lsl.w    #2,d1        ; 10
  601.         or.l    d0,d1        ;  8
  602.         move.l    d1,d2        ;  4
  603.         b7                ; plane 1
  604.         lsr.l    #7,d2        ; 22
  605.         move.l    d1,d0        ;  4
  606.         and.l    d6,d0        ;  8 d6=$55555555
  607.         eor.l    d0,d1        ;  8
  608.         move.l    d2,d4        ;  4
  609.         and.l    d6,d4        ;  8 d6=$55555555
  610.         eor.l    d4,d2        ;  8
  611.         b8                ; plane 0
  612.         sub.w    #1,(sp)
  613.         bne.w    restart
  614.     else
  615.     ifeq depth-4
  616.         b0
  617.         b5                ; plane 3
  618.         move.l    (a0)+,d2    ; 12 get next 4 chunky pixels in d2
  619.         move.l    (a0)+,d3    ; 12 get next 4 chunky pixels in d3
  620.         lsl.l    #4,d2        ; 16
  621.         or.l    d3,d2        ;  8
  622.         move.l    d2,d3        ;  4
  623.         and.l    d7,d3        ;  8 d7=$3333cccc
  624.         eor.l    d3,d2        ;  8
  625.         b6                ; plane 2
  626.         lsr.w    #2,d3        ; 10
  627.         swap    d3        ;  4
  628.         lsl.w    #2,d3        ; 10
  629.         or.l    d2,d3        ;  8
  630.         move.l    d3,d2        ;  4
  631.         lsr.l    #7,d2        ; 22
  632.         move.l    d3,d0        ;  4
  633.         b7                ; plane 1
  634.         and.l    d6,d0        ;  8 d6=$55555555
  635.         eor.l    d0,d3        ;  8
  636.         move.l    d2,d1        ;  4
  637.         and.l    d6,d1        ;  8 d6=$55555555
  638.         eor.l    d1,d2        ;  8
  639.         or.l    d1,d3        ;  8
  640.         lsr.l    #1,d3        ; 10
  641.         b8                ; plane 0
  642.         sub.w    #1,(sp)
  643.         bne.w    restart2
  644.     else
  645.         die    "Unsupported depth"
  646.     endc
  647.     endc
  648.     endc
  649.  
  650.         jmp    (endcode)    ; break out of relocated code
  651. endcode:
  652.  
  653. ; CPU all done!  restore stack
  654.  
  655.     ifd generic
  656.         add.w    #10,sp            ; remove stack vars
  657.     else
  658.         addq.l    #2,sp            ; remove outer loop counter
  659.     endc
  660.  
  661. ; find out how long it took
  662.  
  663.         lea    (endcputime-buffers,a3),a0
  664.         movea.l    (timerbase-buffers,a3),a6    ; timerbase
  665.         jsr    (_LVOReadEClock,a6)
  666.  
  667. ; wait for the blitter to finish
  668. ; busy-wait (for a very short time) on FAST bus, even on a CHIP-only machine
  669.  
  670.         movea.l    (gfxbase-buffers,a3),a6
  671.         bra.b    endwaitloop
  672. waitloop:    jsr    (_LVOWaitBlit,a6)
  673. endwaitloop:    tst.b    (waitflag-buffers,a3)
  674.         bne.b    waitloop
  675.  
  676. ; get blittime,cputime,n_blit in d2,d3,d0
  677.  
  678.         move.l    (endblittime+4-buffers,a3),d2
  679.         sub.l    (starttime+4-buffers,a3),d2
  680.  
  681.         move.l    (endcputime+4-buffers,a3),d3
  682.         sub.l    (starttime+4-buffers,a3),d3
  683.  
  684.         move.l    (n_blit-buffers,a3),d0
  685.  
  686. ; branch if this is not the first time through
  687.  
  688.         bset    #0,(firsttimeflag-buffers,a3)
  689.         bne.b    simple
  690.  
  691. ; calculate new partition point for next call using formula
  692. ; n_blit = n * (t_cpu * n_blit / (t_blit * n_cpu + t_cpu * n_blit))
  693. ; d0     = plsiz/4 * d3 * d0 / (d2 * (plsiz/4 - d0) + d3 * d0)
  694.  
  695.         movea.l    (utilitybase-buffers,a3),a6
  696.  
  697.         moveq    #10,d4
  698.         lsr.l    d4,d2            ; scale t_blit (avoid overflow)
  699.         lsr.l    d4,d3            ; scale t_cpu
  700.  
  701.         move.l    d0,d4
  702.         move.l    d3,d1
  703.         jsr    (_LVOUMult32,a6)
  704.         move.l    d0,d3
  705.  
  706.     ifd generic
  707.         move.l    (v_plsiz-buffers,a3),d1
  708.         lsr.l    #2,d1
  709.     else
  710.         move.l    #plsiz/4,d1
  711.     endc
  712.         jsr    (_LVOUMult32,a6)
  713.         move.l    d0,d5
  714.  
  715.     ifd generic
  716.         move.l    (v_plsiz-buffers,a3),d0
  717.         lsr.l    #2,d0
  718.     else
  719.         move.l    #plsiz/4,d0
  720.     endc
  721.         sub.l    d4,d0
  722.         move.l    d2,d1
  723.         jsr    (_LVOUMult32,a6)
  724.         add.l    d0,d3
  725.  
  726.         move.l    d5,d0
  727.         move.l    d3,d1
  728.         jsr    (_LVOUDivMod32,a6)
  729.  
  730.         bra.b    done
  731.  
  732. ; simple-minded adjustment
  733.  
  734. simple:        sub.l    d3,d2            ; blittime-cputime
  735.         beq.b    alldone            ; can't do better than this
  736.         bgt.b    1$
  737. ; blittime < cputime, increase n_blit
  738.         addq.l    #8,d0
  739.     ifd generic
  740.         move.l    (v_plsiz-buffers,a3),d1
  741.         lsr.l    #2,d1
  742.         cmp.l    d1,d0
  743.     else
  744.         cmp.l    #plsiz/4,d0
  745.     endc
  746.         bcs.b    done
  747.         bra.b    alldone            ; don't go out of range
  748. ; blittime > cputime, decrease n_blit
  749. 1$:        subq.l    #8,d0
  750.         bhi.b    done
  751.         bra.b    alldone            ; don't go out of range
  752.  
  753. ; save the new partition point
  754.  
  755. done:        move.l    d0,(n_blit-buffers,a3)
  756.         lsl.l    #2,d0
  757.         move.l    d0,(plsiz_blit-buffers,a3)
  758.         lsl.l    #3,d0
  759.         move.l    d0,(pixels_blit-buffers,a3)
  760.  
  761. ; all done!
  762.  
  763. alldone:    movem.l    (sp)+,d2-d7/a2-a6
  764.         rts
  765.  
  766. ;-----------------------------------------------------------------------------
  767. ; QBlit functions (called asynchronously)
  768.  
  769. blit11:        moveq    #-1,d0
  770.         move.l    d0,(bltafwm,a0)
  771.         move.l    #(8<<16)+8,(bltbmod,a0)    ; also loads bltamod
  772.         move.w    #0,(bltdmod,a0)
  773.         move.l    (source-mybltnode,a1),d0
  774.         move.l    d0,(bltapt,a0)        ; source
  775.         addq.l    #8,d0
  776.         move.l    d0,(bltbpt,a0)        ; source+8
  777.         move.w    #%1111111100000000,(bltcdat,a0)
  778.         move.l    (buff1-mybltnode,a1),(bltdpt,a0) ; buff1
  779.         move.l    #$0DE48000,(bltcon0,a0)    ; D=AC+(B>>8)~C
  780.         move.l    (pixels_blit-mybltnode,a1),d0
  781.         lsr.l    #4,d0
  782.         move.w    d0,(bltsizv,a0)        ; pixels_blit/16
  783.         move.w    #4,(bltsizh,a0)        ; do blit
  784.         lea    (blit12,pc),a0
  785.         move.l    a0,(qblitfunc-mybltnode,a1)
  786.         rts
  787.  
  788. blit12:        move.l    (source-mybltnode,a1),d0
  789.         add.l    (pixels_blit-mybltnode,a1),d0
  790.         sub.l    #8+2,d0
  791.         move.l    d0,(bltapt,a0)        ; source+pixels_blit-8-2
  792.         addq.l    #8,d0
  793.         move.l    d0,(bltbpt,a0)        ; source+pixels_blit-2
  794.         sub.l    (source-mybltnode,a1),d0
  795.         add.l    (buff1-mybltnode,a1),d0
  796.         move.l    d0,(bltdpt,a0)        ; buff1+pixels_blit-2
  797.         move.l    #$8DE40002,(bltcon0,a0)    ; D=(A<<8)C+B~C, desc.
  798.         move.w    #4,(bltsizh,a0)        ; do blit
  799.         lea    (blit21,pc),a0
  800.         move.l    a0,(qblitfunc-mybltnode,a1)
  801.         rts
  802.  
  803. blit21:        move.l    #(4<<16)+4,(bltbmod,a0)    ; also load bltamod
  804.         move.l    (buff1-mybltnode,a1),d1
  805.         move.l    d1,(bltapt,a0)        ; buff1
  806.         addq.l    #4,d1
  807.         move.l    d1,(bltbpt,a0)        ; buff1+4
  808.         move.w    #%1111000011110000,(bltcdat,a0)
  809.         move.l    (buff0-mybltnode,a1),(bltdpt,a0) ; buff0
  810.         move.l    #$0DE44000,(bltcon0,a0)    ; D=AC+(B>>4)~C
  811.         move.l    (pixels_blit-mybltnode,a1),d0
  812.         lsr.l    #3,d0            ; bltsizv = pixels_blit/8
  813. blit21a:    cmp.l    #32768,d0        ; check for overflow blitter
  814.         bls.b    blit21c            ; branch if ok
  815.         move.l    d0,(tmp_ptr-mybltnode,a1) ; else save (too big) bltsizv
  816.         move.w    #32768,(bltsizv,a0)    ; max possible bltsizv
  817.         move.w    #1,(bltsizh,a0)        ; do blit
  818.         lea    (blit21b,pc),a0
  819.         move.l    a0,(qblitfunc-mybltnode,a1)
  820.         rts
  821.  
  822. blit21b:    move.l    (tmp_ptr-mybltnode,a1),d0 ; restore (too big) bltsizv
  823.         sub.l    #32768,d0        ; subtract number already done
  824.         bra.b    blit21a            ; loop back
  825.  
  826. blit21c:    move.w    d0,(bltsizv,a0)        ; pixels_blit/8
  827.         move.w    #2,(bltsizh,a0)        ; do blit
  828.         lea    (blit22,pc),a0
  829.         move.l    a0,(qblitfunc-mybltnode,a1)
  830.         rts
  831.  
  832. blit22:        move.l    (buff1-mybltnode,a1),d0
  833.         add.l    (pixels_blit-mybltnode,a1),d0
  834.         subq.l    #2+4,d0
  835.         move.l    d0,(bltapt,a0)        ; buff1+pixels_blit-2-4
  836.         addq.l    #4,d0
  837.         move.l    d0,(bltbpt,a0)        ; buff1+pixels_blit-2
  838.         sub.l    (buff1-mybltnode,a1),d0
  839.         add.l    (buff0-mybltnode,a1),d0
  840.         move.l    d0,(bltdpt,a0)        ; buff0+pixels_blit-2
  841.         move.l    #$4DE40002,(bltcon0,a0)    ; D=(A<<4)C+B~C, desc.
  842.         move.l    (pixels_blit-mybltnode,a1),d0
  843.         lsr.l    #3,d0            ; bltsizv = pixels_blit/8
  844. blit22a:    cmp.l    #32768,d0        ; check for overflow blitter
  845.         bls.b    blit22c            ; branch if ok
  846.         move.l    d0,(tmp_ptr-mybltnode,a1) ; else save (too big) bltsizv
  847.         move.w    #32768,(bltsizv,a0)    ; max possible bltsizv
  848.         move.w    #1,(bltsizh,a0)        ; do blit
  849.         lea    (blit22b,pc),a0
  850.         move.l    a0,(qblitfunc-mybltnode,a1)
  851.         rts
  852.  
  853. blit22b:    move.l    (tmp_ptr-mybltnode,a1),d0 ; restore (too big) bltsizv
  854.         sub.l    #32768,d0        ; subtract number already done
  855.         bra.b    blit22a            ; loop back
  856.  
  857. blit22c:    move.w    d0,(bltsizv,a0)        ; pixels_blit/8
  858.         move.w    #2,(bltsizh,a0)        ; do blit
  859.         lea    (blit31,pc),a0
  860.         move.l    a0,(qblitfunc-mybltnode,a1)
  861.         rts
  862.  
  863. blit31:        move.l    #(2<<16)+2,(bltbmod,a0)    ; also load bltamod
  864.         move.l    (buff0-mybltnode,a1),d0
  865.         move.l    d0,(bltapt,a0)        ; buff0
  866.         addq.l    #2,d0
  867.         move.l    d0,(bltbpt,a0)        ; buff0+2
  868.         move.w    #%1100110011001100,(bltcdat,a0)
  869.         move.l    (buff1-mybltnode,a1),(bltdpt,a0) ; buff1
  870.         move.l    #$0DE42000,(bltcon0,a0)    ; D=AC+(B>>2)~C
  871.         move.l    (pixels_blit-mybltnode,a1),d0
  872.         lsr.l    #2,d0            ; bltsizv = pixels_blit/4
  873. blit31a:    cmp.l    #32768,d0        ; check for overflow blitter
  874.         bls.b    blit31c            ; branch if ok
  875.         move.l    d0,(tmp_ptr-mybltnode,a1) ; else save (too big) bltsizv
  876.         move.w    #32768,(bltsizv,a0)    ; max possible bltsizv
  877.         move.w    #1,(bltsizh,a0)        ; do blit
  878.         lea    (blit31b,pc),a0
  879.         move.l    a0,(qblitfunc-mybltnode,a1)
  880.         rts
  881.  
  882. blit31b:    move.l    (tmp_ptr-mybltnode,a1),d0 ; restore (too big) bltsizv
  883.         sub.l    #32768,d0        ; subtract number already done
  884.         bra.b    blit31a            ; loop back
  885.  
  886. blit31c:    move.w    d0,(bltsizv,a0)        ; pixels_blit/4
  887.         move.w    #1,(bltsizh,a0)        ; do final blit
  888.         lea    (blit32,pc),a0
  889.         move.l    a0,(qblitfunc-mybltnode,a1)
  890.         rts
  891.  
  892. blit32:        move.l    (buff0-mybltnode,a1),d0
  893.         add.l    (pixels_blit-mybltnode,a1),d0
  894.         subq.l    #2+2,d0
  895.         move.l    d0,(bltapt,a0)        ; buff0+pixels_blit-2-2
  896.         addq.l    #2,d0
  897.         move.l    d0,(bltbpt,a0)        ; buff0+pixels_blit-2
  898.         sub.l    (buff0-mybltnode,a1),d0
  899.         add.l    (buff1-mybltnode,a1),d0
  900.         move.l    d0,(bltdpt,a0)        ; buff1+pixels_blit-2
  901.         move.l    #$2DE40002,(bltcon0,a0)    ; D=(A<<2)C+B~C, desc.
  902.         move.l    (pixels_blit-mybltnode,a1),d0
  903.         lsr.l    #2,d0            ; bltsizv = pixels_blit/4
  904. blit32a:    cmp.l    #32768,d0        ; check for overflow blitter
  905.         bls.b    blit32c            ; branch if ok
  906.         move.l    d0,(tmp_ptr-mybltnode,a1) ; else save (too big) bltsizv
  907.         move.w    #32768,(bltsizv,a0)    ; max possible bltsizv
  908.         move.w    #1,(bltsizh,a0)        ; do blit
  909.         lea    (blit32b,pc),a0
  910.         move.l    a0,(qblitfunc-mybltnode,a1)
  911.         rts
  912.  
  913. blit32b:    move.l    (tmp_ptr-mybltnode,a1),d0 ; restore (too big) bltsizv
  914.         sub.l    #32768,d0        ; subtract number already done
  915.         bra.b    blit32a            ; loop back
  916.  
  917. blit32c:    move.w    d0,(bltsizv,a0)        ; pixels_blit/4
  918.         move.w    #1,(bltsizh,a0)        ; do blit
  919.         lea    (blit41,pc),a0
  920.         move.l    a0,(qblitfunc-mybltnode,a1)
  921.         rts
  922.  
  923. blit41:        moveq    #0,d0
  924.         move.l    d0,(bltbmod,a0)        ; also load bltamod
  925.         move.l    (buff1-mybltnode,a1),d0
  926.         move.l    d0,(bltapt,a0)        ; buff1+0*plsiz_blit
  927.         add.l    (plsiz_blit-mybltnode,a1),d0
  928.         move.l    d0,(bltbpt,a0)        ; buff1+1*plsiz_blit
  929.         move.l    d0,(tmp_ptr-mybltnode,a1)
  930.         move.w    #%1010101010101010,(bltcdat,a0)
  931.         move.l    (plane0-mybltnode,a1),d0
  932.     ifd generic
  933.         move.l    (v_plsiz-mybltnode,a1),d1
  934.         lsl.l    #3,d1
  935.         sub.l    (v_plsiz-mybltnode,a1),d1
  936.         add.l    d1,d0
  937.     else
  938.         add.l    #7*plsiz,d0
  939.     endc
  940.         move.l    d0,(bltdpt,a0)        ; Plane7
  941.         move.l    (pixels_blit-mybltnode,a1),d0
  942.         lsr.l    #4,d0
  943.         move.w    d0,(bltsizv,a0)        ; pixels_blit/16
  944.         move.l    #$0DE41000,(bltcon0,a0)    ; D=AC+(B>>1)~C
  945.         move.w    #1,(bltsizh,a0)        ; do blit
  946.         lea    (blit42,pc),a0
  947.         move.l    a0,(qblitfunc-mybltnode,a1)
  948.         rts
  949.  
  950. blit42:        move.l    (plsiz_blit-mybltnode,a1),d1
  951.         move.l    (tmp_ptr-mybltnode,a1),d0
  952.         add.l    d1,d0
  953.         move.l    d0,(bltapt,a0)        ; buff1+2*plsiz_blit
  954.         add.l    d1,d0
  955.         move.l    d0,(bltbpt,a0)        ; buff1+3*plsiz_blit
  956.         move.l    d0,(tmp_ptr-mybltnode,a1)
  957.         move.l    (plane0-mybltnode,a1),d0
  958.     ifd generic
  959.         move.l    (v_plsiz-mybltnode,a1),d1
  960.         add.l    d1,d0
  961.         add.l    d1,d0
  962.         add.l    d1,d0
  963.     else
  964.         add.l    #3*plsiz,d0
  965.     endc
  966.         move.l    d0,(bltdpt,a0)        ; Plane3
  967.         move.w    #1,(bltsizh,a0)        ; do blit
  968.         lea    (blit43,pc),a0
  969.         move.l    a0,(qblitfunc-mybltnode,a1)
  970.         rts
  971.  
  972. blit43:        move.l    (plsiz_blit-mybltnode,a1),d1
  973.         move.l    (tmp_ptr-mybltnode,a1),d0
  974.         add.l    d1,d0
  975.         move.l    d0,(bltapt,a0)        ; buff1+4*plsiz_blit
  976.         add.l    d1,d0
  977.         move.l    d0,(bltbpt,a0)        ; buff1+5*plsiz_blit
  978.         move.l    d0,(tmp_ptr-mybltnode,a1)
  979.         move.l    (plane0-mybltnode,a1),d0
  980.     ifd generic
  981.         move.l    (v_plsiz-mybltnode,a1),d1
  982.         add.l    d1,d0
  983.         lsl.l    #2,d1
  984.         add.l    d1,d0
  985.     else
  986.         add.l    #5*plsiz,d0
  987.     endc
  988.         move.l    d0,(bltdpt,a0)        ; Plane5
  989.         move.w    #1,(bltsizh,a0)        ; do blit
  990.         lea    (blit44,pc),a0
  991.         move.l    a0,(qblitfunc-mybltnode,a1)
  992.         rts
  993.  
  994. blit44:        move.l    (plsiz_blit-mybltnode,a1),d1
  995.         move.l    (tmp_ptr-mybltnode,a1),d0
  996.         add.l    d1,d0
  997.         move.l    d0,(bltapt,a0)        ; buff1+6*plsiz_blit
  998.         add.l    d1,d0
  999.         move.l    d0,(bltbpt,a0)        ; buff1+7*plsiz_blit
  1000.         move.l    d0,(tmp_ptr-mybltnode,a1)
  1001.         move.l    (plane0-mybltnode,a1),d0
  1002.     ifd generic
  1003.         add.l    (v_plsiz-mybltnode,a1),d0
  1004.     else
  1005.         add.l    #1*plsiz,d0
  1006.     endc
  1007.         move.l    d0,(bltdpt,a0)        ; Plane1
  1008.         move.w    #1,(bltsizh,a0)        ; do blit
  1009.         lea    (blit45,pc),a0
  1010.         move.l    a0,(qblitfunc-mybltnode,a1)
  1011.         rts
  1012.  
  1013. blit45:        move.l    (plsiz_blit-mybltnode,a1),d1
  1014.         move.l    (tmp_ptr-mybltnode,a1),d0
  1015.         add.l    d1,d0
  1016.         subq.l    #2,d0
  1017.         move.l    d0,(bltbpt,a0)        ; buff1+8*plsiz_blit-2
  1018.         sub.l    d1,d0
  1019.         move.l    d0,(bltapt,a0)        ; buff1+7*plsiz_blit-2
  1020.         move.l    d0,(tmp_ptr-mybltnode,a1)
  1021.         move.l    (plane0-mybltnode,a1),d0
  1022.         add.l    d1,d0
  1023.         subq.l    #2,d0
  1024.         move.l    d0,(bltdpt,a0)        ; Plane0
  1025.         move.l    #$1DE40002,(bltcon0,a0)    ; D=(A<<1)C+B~C, desc.
  1026.         move.w    #1,(bltsizh,a0)        ; do blit
  1027.         lea    (blit46,pc),a0
  1028.         move.l    a0,(qblitfunc-mybltnode,a1)
  1029.         rts
  1030.  
  1031. blit46:        move.l    (plsiz_blit-mybltnode,a1),d1
  1032.         move.l    (tmp_ptr-mybltnode,a1),d0
  1033.         sub.l    d1,d0
  1034.         move.l    d0,(bltbpt,a0)        ; buff1+6*plsiz_blit-2
  1035.         sub.l    d1,d0
  1036.         move.l    d0,(bltapt,a0)        ; buff1+5*plsiz_blit-2
  1037.         move.l    d0,(tmp_ptr-mybltnode,a1)
  1038.         move.l    (plane0-mybltnode,a1),d0
  1039.         add.l    d1,d0
  1040.     ifd generic
  1041.         move.l    (v_plsiz-mybltnode,a1),d1
  1042.         lsl.l    #2,d1
  1043.         add.l    d1,d0
  1044.         subq.l    #2,d0
  1045.     else
  1046.         add.l    #4*plsiz-2,d0
  1047.     endc
  1048.         move.l    d0,(bltdpt,a0)        ; Plane4
  1049.         move.w    #1,(bltsizh,a0)        ; do blit
  1050.         lea    (blit47,pc),a0
  1051.         move.l    a0,(qblitfunc-mybltnode,a1)
  1052.         rts
  1053.  
  1054. blit47:        move.l    (plsiz_blit-mybltnode,a1),d1
  1055.         move.l    (tmp_ptr-mybltnode,a1),d0
  1056.         sub.l    d1,d0
  1057.         move.l    d0,(bltbpt,a0)        ; buff1+4*plsiz_blit-2
  1058.         sub.l    d1,d0
  1059.         move.l    d0,(bltapt,a0)        ; buff1+3*plsiz_blit-2
  1060.         move.l    d0,(tmp_ptr-mybltnode,a1)
  1061.         move.l    (plane0-mybltnode,a1),d0
  1062.         add.l    d1,d0
  1063.     ifd generic
  1064.         move.l    (v_plsiz-mybltnode,a1),d1
  1065.         add.l    d1,d0
  1066.         add.l    d1,d0
  1067.         subq.l    #2,d0
  1068.     else
  1069.         add.l    #2*plsiz-2,d0
  1070.     endc
  1071.         move.l    d0,(bltdpt,a0)        ; Plane2
  1072.         move.w    #1,(bltsizh,a0)        ; do blit
  1073.         lea    (blit48,pc),a0
  1074.         move.l    a0,(qblitfunc-mybltnode,a1)
  1075.         rts
  1076.  
  1077. blit48:        move.l    (plsiz_blit-mybltnode,a1),d1
  1078.         move.l    (tmp_ptr-mybltnode,a1),d0
  1079.         sub.l    d1,d0
  1080.         move.l    d0,(bltbpt,a0)        ; buff1+2*plsiz_blit-2
  1081.         sub.l    d1,d0
  1082.         move.l    d0,(bltapt,a0)        ; buff1+1*plsiz_blit-2
  1083.         move.l    (plane0-mybltnode,a1),d0
  1084.         add.l    d1,d0
  1085.     ifd generic
  1086.         move.l    (v_plsiz-mybltnode,a1),d1
  1087.         sub.l    d1,d0
  1088.         sub.l    d1,d0
  1089.         lsl.l    #3,d1
  1090.         add.l    d1,d0
  1091.         subq.l    #2,d0
  1092.     else
  1093.         add.l    #6*plsiz-2,d0
  1094.     endc
  1095.         move.l    d0,(bltdpt,a0)        ; Plane6
  1096.         move.w    #1,(bltsizh,a0)        ; do blit
  1097.         lea    (blit11,pc),a0
  1098.         move.l    a0,(qblitfunc-mybltnode,a1)
  1099.         moveq    #0,d0            ; set Z flag
  1100.         rts
  1101.  
  1102. qblitcleanup:    movem.l    a2/a6,-(sp)
  1103.         move.l    #mybltnode,a2
  1104.         lea    (endblittime-mybltnode,a2),a0
  1105.         move.l    (timerbase-mybltnode,a2),a6
  1106.         jsr    (_LVOReadEClock,a6)    ; may be called from interrupts
  1107.         sf    (waitflag-mybltnode,a2)
  1108.         movem.l    (sp)+,a2/a6
  1109.         rts
  1110.  
  1111. ;-----------------------------------------------------------------------------
  1112.  
  1113.         section    data,data
  1114.  
  1115.         quad
  1116. buffers:    dc.l    0,0,0,0,0,0,0,0
  1117. mybltnode:    dc.l    0        ; next bltnode
  1118. qblitfunc:    dc.l    blit11        ; ptr to qblitfunc()
  1119.         dc.b    cleanup        ; stat
  1120.         dc.b    0        ; filler
  1121.         dc.w    0        ; blitsize
  1122.         dc.w    0        ; beamsync
  1123.         dc.l    qblitcleanup    ; ptr to qblitcleanup()
  1124.  
  1125.         quad
  1126. chunky:        dc.l    0        ; ptr to original chunky data
  1127. plane0:        dc.l    0        ; ptr to output planes
  1128. buff0:        dc.l    0        ; ptr to chip buffer0, size = pixels
  1129. buff1:        dc.l    0        ; ptr to chip buffer1, size = pixels
  1130. source:        dc.l    0        ; copy of chunky (if chip) else buff0
  1131.     ifd generic
  1132. v_plsiz:    dc.l    0        ; width*height/8
  1133. v_plsiz_depth:    dc.l    0        ; (depth-1)*width*height/8
  1134. pixels_blit:    dc.l    0        ; number of pixels handled by blitter
  1135. plsiz_blit:    dc.l    0        ; & corresponding (partial) planesize
  1136. n_blit:        dc.l    0        ; number of 32-byte units for blitter
  1137.     else
  1138. pixels_blit:    dc.l    pixels/2    ; number of pixels handled by blitter
  1139. plsiz_blit:    dc.l    plsiz/2        ; & corresponding (partial) planesize
  1140. n_blit:        dc.l    plsiz/4/2    ; number of 32-byte units for blitter
  1141.     endc
  1142. tmp_ptr:    dc.l    0
  1143. gfxbase:    dc.l    0
  1144. timerbase:    dc.l    0
  1145. utilitybase:    dc.l    0
  1146. starttime:    dc.l    0,0
  1147. endblittime:    dc.l    0,0
  1148. endcputime:    dc.l    0,0
  1149. waitflag:    dc.b    0
  1150. firsttimeflag:    dc.b    0
  1151.  
  1152. ;-----------------------------------------------------------------------------
  1153. ;
  1154. ;        section    bss,bss,chip    ; MUST BE IN CHIP !!!!!
  1155. ;
  1156. ;        quad
  1157. ;buff0:        ds.b    pixels        ;Intermediate buffer 1
  1158. ;buff1:        ds.b    pixels        ;Intermediate buffer 1
  1159. ;
  1160. ;-----------------------------------------------------------------------------
  1161.  
  1162.         end
  1163.